/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:张熳
 * Date:2025-08-21
 * Time:19:25
 */
//类和对象

class Student{
    //成员变量
    private String name = "zhaohua";
    private int age;
    private double score;
    //静态成员变量
    private static String className = "1班";//就地初始化

    //也可以通过 setter方法初始化
    public static void setClassName(String className){
        Student.className = className;
    }
    //通过快捷键：
  /* public static String getClassName() {
        return className;
    }

    public static void setClassName(String className) {
        Student.className = className;
    }*/

    //构造方法
    public Student(String name,int age,double score){
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("构造方法执行了...");
        //className = "2班";//通过构造方法初始化（相对较少用）
    }
    public Student(){
        System.out.println("Student()构造方法执行了...");
    }

    //通过公共方法提供接口访问私有成员变量
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }

    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }

    //成员方法
    public void doClass(){
        System.out.println(this.name + " 正在上课....");
    }
    public void show(){
        System.out.println("姓名: "+this.name+" 年龄: "+this.age+" 成绩: "+this.score);
        //getClassName();//非静态方法中可以直接调用静态方法(同一个类中)
    }

    //静态成员方法/类方法/静态方法
    public static String getClassName(){
        //不能在静态方法中访问任何非静态成员变量
        //age += 1;
        //System.out.println(this.score);//this关键字在静态方法中不可使用，就算创建实例化对象也不可以使用
        //静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用
        //show();
        //解决方法就是创建实例化对象
        //Student student = new Student("lisi",11,85);
        //student.show();
        //静态方法中访问非静态成员变量同理
        //student.age += 1;
        return className;
    }

    //构造代码块 - 定义在类中（没有条件），一般用于初始化实例成员变量
    /*{
        this.name = "wangwu";
        this.age = 14;
        this.score = 86.5;
        System.out.println("构造代码块初始化成员变量");
    }*/
    //静态代码块 - 定义在类中，使用static修饰，一般用于初始化静态成员变量
    //当类加载的时候就会被触发，如果出现多个静态代码块，都是静态的情况下，和定义的顺序有关系
    static {
        className = "2班";
        //score = 90; error
        System.out.println("静态代码块当中，一般用于初始化静态成员变量");
    }

    //构造代码块在实例化对象的时候会被触发
    {
        this.name = "xiaohua";
        System.out.println("构造代码块/实例代码块...");
    }

    //编译器生成一个toString方法
    @Override
   /* public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }*/
    //自己写一个toString方法
    public String toString(){
      return "wanghua";
    }
}

public class Test {
    public static void main(String[] args) {
        //对象的打印
        Student student = new Student("zhangsan",15,65);
        System.out.println(student);
    }
    public static void main5(String[] args) {
        Student student = new Student();
        System.out.println("=========");
        Student student1 = new Student();

        //System.out.println(student.getName());
    }
    public static void main4(String[] args) {
        //说明执行顺序
        //构造代码块
        Student student = new Student("zhangsan",15,65);
        System.out.println(student.getName());
        //静态代码块
        //System.out.println(Student.getClassName());//2班
    }
    public static void main3(String[] args) {
        //代码块
        //普通代码块（局部代码块） - 定义在方法中（没有条件）
        {
            int a = 10;
            System.out.println(a);
        }
        //System.out.println(a);//在代码块内声明的变量只在该块内有效,出了作用域就释放掉

        //构造代码块
        Student student = new Student();
        student.show();
    }
    //如果add方法是一个静态方法，那么它就可以在同样是静态方法的main方法中直接调用
    public static int add(int a,int b){
        return a+b;
    }
    //如果add方法是非静态方法，而main方法也是可以调用非静态方法的，但必须先创建类的实例
    public int add1(int a,int b){
        return a+b;
    }

    public static void main2(String[] args) {
        Test test = new Test();
        System.out.println(test.add1(10, 20));

        System.out.println(add(10, 20));

        //static修饰的成员方法
        //Student student1 = new Student("lisi",10,75);
        //System.out.println(student1.className);//会编译错误，因为className被private修饰

        //当静态成员被private修饰时，该如何在类外访问 --- 静态成员一般是通过静态方法来访问的
        //类方法和类成员一样，不需要实例化对象然后进行访问,而是通过类进行访问
        System.out.println(Student.getClassName());
    }
    public static void main1(String[] args) {
        Student student1 = new Student("lisi",10,75);
        student1.show();
        Student student2 = new Student("zhangsan",11,85);
        student2.show();
        Student student3 = new Student("wangwu",12,95);
        student3.show();
    }
}

